﻿using System;

namespace HslCommunication
{
	/// <summary>
	/// 操作结果的类，只带有成功标志和错误信息<br />
	/// The class that operates the result, with only success flags and error messages
	/// </summary>
	/// <remarks>
	/// 当 <see cref="P:HslCommunication.OperateResult.IsSuccess" /> 为 True 时，忽略 <see cref="P:HslCommunication.OperateResult.Message" /> 及 <see cref="P:HslCommunication.OperateResult.ErrorCode" /> 的值
	/// </remarks>
	// Token: 0x02000014 RID: 20
	public class OperateResult
	{
		/// <summary>
		/// 实例化一个默认的结果对象
		/// </summary>
		// Token: 0x060000CA RID: 202 RVA: 0x00005010 File Offset: 0x00003210
		public OperateResult()
		{
		}

		/// <summary>
		/// 使用指定的消息实例化一个默认的结果对象
		/// </summary>
		/// <param name="msg">错误消息</param>
		// Token: 0x060000CB RID: 203 RVA: 0x00005035 File Offset: 0x00003235
		public OperateResult(string msg)
		{
			this.Message = msg;
		}

		/// <summary>
		/// 使用错误代码，消息文本来实例化对象
		/// </summary>
		/// <param name="err">错误代码</param>
		/// <param name="msg">错误消息</param>
		// Token: 0x060000CC RID: 204 RVA: 0x00005062 File Offset: 0x00003262
		public OperateResult(int err, string msg)
		{
			this.ErrorCode = err;
			this.Message = msg;
		}

		/// <summary>
		/// 指示本次操作是否成功。<br />
		/// Indicates whether this operation was successful.
		/// </summary>
		// Token: 0x17000046 RID: 70
		// (get) Token: 0x060000CD RID: 205 RVA: 0x00005097 File Offset: 0x00003297
		// (set) Token: 0x060000CE RID: 206 RVA: 0x0000509F File Offset: 0x0000329F
		public bool IsSuccess { get; set; }

		/// <summary>
		/// 具体的错误描述。<br />
		/// Specific error description.
		/// </summary>
		// Token: 0x17000047 RID: 71
		// (get) Token: 0x060000CF RID: 207 RVA: 0x000050A8 File Offset: 0x000032A8
		// (set) Token: 0x060000D0 RID: 208 RVA: 0x000050B0 File Offset: 0x000032B0
		public string Message { get; set; } = StringResources.Language.UnknownError;

		/// <summary>
		/// 具体的错误代码。<br />
		/// The specific error code.
		/// </summary>
		// Token: 0x17000048 RID: 72
		// (get) Token: 0x060000D1 RID: 209 RVA: 0x000050B9 File Offset: 0x000032B9
		// (set) Token: 0x060000D2 RID: 210 RVA: 0x000050C1 File Offset: 0x000032C1
		public int ErrorCode { get; set; } = 10000;

		/// <summary>
		/// 获取错误代号及文本描述。<br />
		/// Get the error code and text description.
		/// </summary>
		/// <returns>包含错误码及错误消息</returns>
		// Token: 0x060000D3 RID: 211 RVA: 0x000050CC File Offset: 0x000032CC
		public string ToMessageShowString()
		{
			return string.Format("{0}:{1}{2}{3}:{4}", new object[]
			{
				StringResources.Language.ErrorCode,
				this.ErrorCode,
				Environment.NewLine,
				StringResources.Language.TextDescription,
				this.Message
			});
		}

		/// <summary>
		/// 从另一个结果类中拷贝错误信息，主要是针对错误码和错误消息。<br />
		/// Copy error information from another result class, mainly for error codes and error messages.
		/// </summary>
		/// <typeparam name="TResult">支持结果类及派生类</typeparam>
		/// <param name="result">结果类及派生类的对象</param>
		// Token: 0x060000D4 RID: 212 RVA: 0x00005124 File Offset: 0x00003324
		public void CopyErrorFromOther<TResult>(TResult result) where TResult : OperateResult
		{
			bool flag = result != null;
			if (flag)
			{
				this.ErrorCode = result.ErrorCode;
				this.Message = result.Message;
			}
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T">结果类型</typeparam>
		/// <param name="content">如果操作成功将赋予的结果内容</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000D5 RID: 213 RVA: 0x00005165 File Offset: 0x00003365
		public OperateResult<T> Convert<T>(T content)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T>(content) : OperateResult.CreateFailedResult<T>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T">结果类型</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000D6 RID: 214 RVA: 0x0000517D File Offset: 0x0000337D
		public OperateResult<T> ConvertFailed<T>()
		{
			return OperateResult.CreateFailedResult<T>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000D7 RID: 215 RVA: 0x00005185 File Offset: 0x00003385
		public OperateResult<T1, T2> Convert<T1, T2>(T1 content1, T2 content2)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2>(content1, content2) : OperateResult.CreateFailedResult<T1, T2>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000D8 RID: 216 RVA: 0x0000519E File Offset: 0x0000339E
		public OperateResult<T1, T2> ConvertFailed<T1, T2>()
		{
			return OperateResult.CreateFailedResult<T1, T2>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <param name="content3">如果操作成功将赋予的结果内容三</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000D9 RID: 217 RVA: 0x000051A6 File Offset: 0x000033A6
		public OperateResult<T1, T2, T3> Convert<T1, T2, T3>(T1 content1, T2 content2, T3 content3)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2, T3>(content1, content2, content3) : OperateResult.CreateFailedResult<T1, T2, T3>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000DA RID: 218 RVA: 0x000051C0 File Offset: 0x000033C0
		public OperateResult<T1, T2, T3> ConvertFailed<T1, T2, T3>()
		{
			return OperateResult.CreateFailedResult<T1, T2, T3>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <param name="content3">如果操作成功将赋予的结果内容三</param>
		/// <param name="content4">如果操作成功将赋予的结果内容四</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000DB RID: 219 RVA: 0x000051C8 File Offset: 0x000033C8
		public OperateResult<T1, T2, T3, T4> Convert<T1, T2, T3, T4>(T1 content1, T2 content2, T3 content3, T4 content4)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2, T3, T4>(content1, content2, content3, content4) : OperateResult.CreateFailedResult<T1, T2, T3, T4>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000DC RID: 220 RVA: 0x000051E4 File Offset: 0x000033E4
		public OperateResult<T1, T2, T3, T4> ConvertFailed<T1, T2, T3, T4>()
		{
			return OperateResult.CreateFailedResult<T1, T2, T3, T4>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <param name="content3">如果操作成功将赋予的结果内容三</param>
		/// <param name="content4">如果操作成功将赋予的结果内容四</param>
		/// <param name="content5">如果操作成功将赋予的结果内容五</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000DD RID: 221 RVA: 0x000051EC File Offset: 0x000033EC
		public OperateResult<T1, T2, T3, T4, T5> Convert<T1, T2, T3, T4, T5>(T1 content1, T2 content2, T3 content3, T4 content4, T5 content5)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2, T3, T4, T5>(content1, content2, content3, content4, content5) : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000DE RID: 222 RVA: 0x0000520A File Offset: 0x0000340A
		public OperateResult<T1, T2, T3, T4, T5> ConvertFailed<T1, T2, T3, T4, T5>()
		{
			return OperateResult.CreateFailedResult<T1, T2, T3, T4, T5>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <param name="content3">如果操作成功将赋予的结果内容三</param>
		/// <param name="content4">如果操作成功将赋予的结果内容四</param>
		/// <param name="content5">如果操作成功将赋予的结果内容五</param>
		/// <param name="content6">如果操作成功将赋予的结果内容六</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000DF RID: 223 RVA: 0x00005212 File Offset: 0x00003412
		public OperateResult<T1, T2, T3, T4, T5, T6> Convert<T1, T2, T3, T4, T5, T6>(T1 content1, T2 content2, T3 content3, T4 content4, T5 content5, T6 content6)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2, T3, T4, T5, T6>(content1, content2, content3, content4, content5, content6) : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000E0 RID: 224 RVA: 0x00005232 File Offset: 0x00003432
		public OperateResult<T1, T2, T3, T4, T5, T6> ConvertFailed<T1, T2, T3, T4, T5, T6>()
		{
			return OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <param name="content3">如果操作成功将赋予的结果内容三</param>
		/// <param name="content4">如果操作成功将赋予的结果内容四</param>
		/// <param name="content5">如果操作成功将赋予的结果内容五</param>
		/// <param name="content6">如果操作成功将赋予的结果内容六</param>
		/// <param name="content7">如果操作成功将赋予的结果内容七</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000E1 RID: 225 RVA: 0x0000523A File Offset: 0x0000343A
		public OperateResult<T1, T2, T3, T4, T5, T6, T7> Convert<T1, T2, T3, T4, T5, T6, T7>(T1 content1, T2 content2, T3 content3, T4 content4, T5 content5, T6 content6, T7 content7)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2, T3, T4, T5, T6, T7>(content1, content2, content3, content4, content5, content6, content7) : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000E2 RID: 226 RVA: 0x0000525C File Offset: 0x0000345C
		public OperateResult<T1, T2, T3, T4, T5, T6, T7> ConvertFailed<T1, T2, T3, T4, T5, T6, T7>()
		{
			return OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <param name="content3">如果操作成功将赋予的结果内容三</param>
		/// <param name="content4">如果操作成功将赋予的结果内容四</param>
		/// <param name="content5">如果操作成功将赋予的结果内容五</param>
		/// <param name="content6">如果操作成功将赋予的结果内容六</param>
		/// <param name="content7">如果操作成功将赋予的结果内容七</param>
		/// <param name="content8">如果操作成功将赋予的结果内容八</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000E3 RID: 227 RVA: 0x00005264 File Offset: 0x00003464
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8> Convert<T1, T2, T3, T4, T5, T6, T7, T8>(T1 content1, T2 content2, T3 content3, T4 content4, T5 content5, T6 content6, T7 content7, T8 content8)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2, T3, T4, T5, T6, T7, T8>(content1, content2, content3, content4, content5, content6, content7, content8) : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000E4 RID: 228 RVA: 0x00005288 File Offset: 0x00003488
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8> ConvertFailed<T1, T2, T3, T4, T5, T6, T7, T8>()
		{
			return OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <typeparam name="T9">泛型参数九</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <param name="content3">如果操作成功将赋予的结果内容三</param>
		/// <param name="content4">如果操作成功将赋予的结果内容四</param>
		/// <param name="content5">如果操作成功将赋予的结果内容五</param>
		/// <param name="content6">如果操作成功将赋予的结果内容六</param>
		/// <param name="content7">如果操作成功将赋予的结果内容七</param>
		/// <param name="content8">如果操作成功将赋予的结果内容八</param>
		/// <param name="content9">如果操作成功将赋予的结果内容九</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000E5 RID: 229 RVA: 0x00005290 File Offset: 0x00003490
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9> Convert<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 content1, T2 content2, T3 content3, T4 content4, T5 content5, T6 content6, T7 content7, T8 content8, T9 content9)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>(content1, content2, content3, content4, content5, content6, content7, content8, content9) : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <typeparam name="T9">泛型参数九</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000E6 RID: 230 RVA: 0x000052C1 File Offset: 0x000034C1
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9> ConvertFailed<T1, T2, T3, T4, T5, T6, T7, T8, T9>()
		{
			return OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，如果当前结果为失败，则返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// if the current result is a failure, then return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <typeparam name="T9">泛型参数九</typeparam>
		/// <typeparam name="T10">泛型参数十</typeparam>
		/// <param name="content1">如果操作成功将赋予的结果内容一</param>
		/// <param name="content2">如果操作成功将赋予的结果内容二</param>
		/// <param name="content3">如果操作成功将赋予的结果内容三</param>
		/// <param name="content4">如果操作成功将赋予的结果内容四</param>
		/// <param name="content5">如果操作成功将赋予的结果内容五</param>
		/// <param name="content6">如果操作成功将赋予的结果内容六</param>
		/// <param name="content7">如果操作成功将赋予的结果内容七</param>
		/// <param name="content8">如果操作成功将赋予的结果内容八</param>
		/// <param name="content9">如果操作成功将赋予的结果内容九</param>
		/// <param name="content10">如果操作成功将赋予的结果内容十</param>
		/// <returns>最终的结果类对象</returns>
		// Token: 0x060000E7 RID: 231 RVA: 0x000052CC File Offset: 0x000034CC
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Convert<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 content1, T2 content2, T3 content3, T4 content4, T5 content5, T6 content6, T7 content7, T8 content8, T9 content9, T10 content10)
		{
			return this.IsSuccess ? OperateResult.CreateSuccessResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(content1, content2, content3, content4, content5, content6, content7, content8, content9, content10) : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this);
		}

		/// <summary>
		/// 将当前的结果对象转换到指定泛型的结果类对象，直接返回指定泛型的失败结果类对象<br />
		/// Convert the current result object to the result class object of the specified generic type, 
		/// and directly return the result class object of the specified generic type failure
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <typeparam name="T9">泛型参数九</typeparam>
		/// <typeparam name="T10">泛型参数十</typeparam>
		/// <returns>最终失败的结果类对象</returns>
		// Token: 0x060000E8 RID: 232 RVA: 0x000052FF File Offset: 0x000034FF
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ConvertFailed<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>()
		{
			return OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000E9 RID: 233 RVA: 0x00005307 File Offset: 0x00003507
		public OperateResult Then(Func<OperateResult> func)
		{
			return this.IsSuccess ? func() : this;
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T">泛型参数</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000EA RID: 234 RVA: 0x0000531A File Offset: 0x0000351A
		public OperateResult<T> Then<T>(Func<OperateResult<T>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000EB RID: 235 RVA: 0x00005332 File Offset: 0x00003532
		public OperateResult<T1, T2> Then<T1, T2>(Func<OperateResult<T1, T2>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000EC RID: 236 RVA: 0x0000534A File Offset: 0x0000354A
		public OperateResult<T1, T2, T3> Then<T1, T2, T3>(Func<OperateResult<T1, T2, T3>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2, T3>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000ED RID: 237 RVA: 0x00005362 File Offset: 0x00003562
		public OperateResult<T1, T2, T3, T4> Then<T1, T2, T3, T4>(Func<OperateResult<T1, T2, T3, T4>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2, T3, T4>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000EE RID: 238 RVA: 0x0000537A File Offset: 0x0000357A
		public OperateResult<T1, T2, T3, T4, T5> Then<T1, T2, T3, T4, T5>(Func<OperateResult<T1, T2, T3, T4, T5>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000EF RID: 239 RVA: 0x00005392 File Offset: 0x00003592
		public OperateResult<T1, T2, T3, T4, T5, T6> Then<T1, T2, T3, T4, T5, T6>(Func<OperateResult<T1, T2, T3, T4, T5, T6>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000F0 RID: 240 RVA: 0x000053AA File Offset: 0x000035AA
		public OperateResult<T1, T2, T3, T4, T5, T6, T7> Then<T1, T2, T3, T4, T5, T6, T7>(Func<OperateResult<T1, T2, T3, T4, T5, T6, T7>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000F1 RID: 241 RVA: 0x000053C2 File Offset: 0x000035C2
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8> Then<T1, T2, T3, T4, T5, T6, T7, T8>(Func<OperateResult<T1, T2, T3, T4, T5, T6, T7, T8>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <typeparam name="T9">泛型参数九</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000F2 RID: 242 RVA: 0x000053DA File Offset: 0x000035DA
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9> Then<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Func<OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this);
		}

		/// <summary>
		/// 指定接下来要做的是内容，当前对象如果成功，就返回接下来的执行结果，如果失败，就返回当前对象本身。<br />
		/// Specify what you want to do next, return the result of the execution of the current object if it succeeds, and return the current object itself if it fails.
		/// </summary>
		/// <typeparam name="T1">泛型参数一</typeparam>
		/// <typeparam name="T2">泛型参数二</typeparam>
		/// <typeparam name="T3">泛型参数三</typeparam>
		/// <typeparam name="T4">泛型参数四</typeparam>
		/// <typeparam name="T5">泛型参数五</typeparam>
		/// <typeparam name="T6">泛型参数六</typeparam>
		/// <typeparam name="T7">泛型参数七</typeparam>
		/// <typeparam name="T8">泛型参数八</typeparam>
		/// <typeparam name="T9">泛型参数九</typeparam>
		/// <typeparam name="T10">泛型参数十</typeparam>
		/// <param name="func">等待当前对象成功后执行的内容</param>
		/// <returns>返回整个方法链最终的成功失败结果</returns>
		// Token: 0x060000F3 RID: 243 RVA: 0x000053F2 File Offset: 0x000035F2
		public OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Then<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Func<OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> func)
		{
			return this.IsSuccess ? func() : OperateResult.CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this);
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T">目标数据类型</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000F4 RID: 244 RVA: 0x0000540C File Offset: 0x0000360C
		public static OperateResult<T> CreateFailedResult<T>(OperateResult result)
		{
			return new OperateResult<T>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000F5 RID: 245 RVA: 0x00005440 File Offset: 0x00003640
		public static OperateResult<T1, T2> CreateFailedResult<T1, T2>(OperateResult result)
		{
			return new OperateResult<T1, T2>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <typeparam name="T3">目标数据类型三</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000F6 RID: 246 RVA: 0x00005474 File Offset: 0x00003674
		public static OperateResult<T1, T2, T3> CreateFailedResult<T1, T2, T3>(OperateResult result)
		{
			return new OperateResult<T1, T2, T3>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <typeparam name="T3">目标数据类型三</typeparam>
		/// <typeparam name="T4">目标数据类型四</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000F7 RID: 247 RVA: 0x000054A8 File Offset: 0x000036A8
		public static OperateResult<T1, T2, T3, T4> CreateFailedResult<T1, T2, T3, T4>(OperateResult result)
		{
			return new OperateResult<T1, T2, T3, T4>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <typeparam name="T3">目标数据类型三</typeparam>
		/// <typeparam name="T4">目标数据类型四</typeparam>
		/// <typeparam name="T5">目标数据类型五</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000F8 RID: 248 RVA: 0x000054DC File Offset: 0x000036DC
		public static OperateResult<T1, T2, T3, T4, T5> CreateFailedResult<T1, T2, T3, T4, T5>(OperateResult result)
		{
			return new OperateResult<T1, T2, T3, T4, T5>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <typeparam name="T3">目标数据类型三</typeparam>
		/// <typeparam name="T4">目标数据类型四</typeparam>
		/// <typeparam name="T5">目标数据类型五</typeparam>
		/// <typeparam name="T6">目标数据类型六</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000F9 RID: 249 RVA: 0x00005510 File Offset: 0x00003710
		public static OperateResult<T1, T2, T3, T4, T5, T6> CreateFailedResult<T1, T2, T3, T4, T5, T6>(OperateResult result)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <typeparam name="T3">目标数据类型三</typeparam>
		/// <typeparam name="T4">目标数据类型四</typeparam>
		/// <typeparam name="T5">目标数据类型五</typeparam>
		/// <typeparam name="T6">目标数据类型六</typeparam>
		/// <typeparam name="T7">目标数据类型七</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000FA RID: 250 RVA: 0x00005544 File Offset: 0x00003744
		public static OperateResult<T1, T2, T3, T4, T5, T6, T7> CreateFailedResult<T1, T2, T3, T4, T5, T6, T7>(OperateResult result)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6, T7>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <typeparam name="T3">目标数据类型三</typeparam>
		/// <typeparam name="T4">目标数据类型四</typeparam>
		/// <typeparam name="T5">目标数据类型五</typeparam>
		/// <typeparam name="T6">目标数据类型六</typeparam>
		/// <typeparam name="T7">目标数据类型七</typeparam>
		/// <typeparam name="T8">目标数据类型八</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000FB RID: 251 RVA: 0x00005578 File Offset: 0x00003778
		public static OperateResult<T1, T2, T3, T4, T5, T6, T7, T8> CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8>(OperateResult result)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6, T7, T8>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <typeparam name="T3">目标数据类型三</typeparam>
		/// <typeparam name="T4">目标数据类型四</typeparam>
		/// <typeparam name="T5">目标数据类型五</typeparam>
		/// <typeparam name="T6">目标数据类型六</typeparam>
		/// <typeparam name="T7">目标数据类型七</typeparam>
		/// <typeparam name="T8">目标数据类型八</typeparam>
		/// <typeparam name="T9">目标数据类型九</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000FC RID: 252 RVA: 0x000055AC File Offset: 0x000037AC
		public static OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9> CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>(OperateResult result)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个失败的结果对象，该对象复制另一个结果对象的错误信息
		/// </summary>
		/// <typeparam name="T1">目标数据类型一</typeparam>
		/// <typeparam name="T2">目标数据类型二</typeparam>
		/// <typeparam name="T3">目标数据类型三</typeparam>
		/// <typeparam name="T4">目标数据类型四</typeparam>
		/// <typeparam name="T5">目标数据类型五</typeparam>
		/// <typeparam name="T6">目标数据类型六</typeparam>
		/// <typeparam name="T7">目标数据类型七</typeparam>
		/// <typeparam name="T8">目标数据类型八</typeparam>
		/// <typeparam name="T9">目标数据类型九</typeparam>
		/// <typeparam name="T10">目标数据类型十</typeparam>
		/// <param name="result">之前的结果对象</param>
		/// <returns>带默认泛型对象的失败结果类</returns>
		// Token: 0x060000FD RID: 253 RVA: 0x000055E0 File Offset: 0x000037E0
		public static OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> CreateFailedResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(OperateResult result)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
			{
				ErrorCode = result.ErrorCode,
				Message = result.Message
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象
		/// </summary>
		/// <returns>成功的结果对象</returns>
		// Token: 0x060000FE RID: 254 RVA: 0x00005614 File Offset: 0x00003814
		public static OperateResult CreateSuccessResult()
		{
			return new OperateResult
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有一个参数对象
		/// </summary>
		/// <typeparam name="T">参数类型</typeparam>
		/// <param name="value">类型的值对象</param>
		/// <returns>成功的结果对象</returns>
		// Token: 0x060000FF RID: 255 RVA: 0x0000564C File Offset: 0x0000384C
		public static OperateResult<T> CreateSuccessResult<T>(T value)
		{
			return new OperateResult<T>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content = value
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有两个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000100 RID: 256 RVA: 0x0000568C File Offset: 0x0000388C
		public static OperateResult<T1, T2> CreateSuccessResult<T1, T2>(T1 value1, T2 value2)
		{
			return new OperateResult<T1, T2>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有三个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <typeparam name="T3">第三个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <param name="value3">类型三对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000101 RID: 257 RVA: 0x000056D4 File Offset: 0x000038D4
		public static OperateResult<T1, T2, T3> CreateSuccessResult<T1, T2, T3>(T1 value1, T2 value2, T3 value3)
		{
			return new OperateResult<T1, T2, T3>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2,
				Content3 = value3
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有四个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <typeparam name="T3">第三个参数类型</typeparam>
		/// <typeparam name="T4">第四个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <param name="value3">类型三对象</param>
		/// <param name="value4">类型四对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000102 RID: 258 RVA: 0x00005724 File Offset: 0x00003924
		public static OperateResult<T1, T2, T3, T4> CreateSuccessResult<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4)
		{
			return new OperateResult<T1, T2, T3, T4>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2,
				Content3 = value3,
				Content4 = value4
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有五个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <typeparam name="T3">第三个参数类型</typeparam>
		/// <typeparam name="T4">第四个参数类型</typeparam>
		/// <typeparam name="T5">第五个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <param name="value3">类型三对象</param>
		/// <param name="value4">类型四对象</param>
		/// <param name="value5">类型五对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000103 RID: 259 RVA: 0x0000577C File Offset: 0x0000397C
		public static OperateResult<T1, T2, T3, T4, T5> CreateSuccessResult<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
		{
			return new OperateResult<T1, T2, T3, T4, T5>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2,
				Content3 = value3,
				Content4 = value4,
				Content5 = value5
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有六个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <typeparam name="T3">第三个参数类型</typeparam>
		/// <typeparam name="T4">第四个参数类型</typeparam>
		/// <typeparam name="T5">第五个参数类型</typeparam>
		/// <typeparam name="T6">第六个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <param name="value3">类型三对象</param>
		/// <param name="value4">类型四对象</param>
		/// <param name="value5">类型五对象</param>
		/// <param name="value6">类型六对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000104 RID: 260 RVA: 0x000057E0 File Offset: 0x000039E0
		public static OperateResult<T1, T2, T3, T4, T5, T6> CreateSuccessResult<T1, T2, T3, T4, T5, T6>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2,
				Content3 = value3,
				Content4 = value4,
				Content5 = value5,
				Content6 = value6
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有七个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <typeparam name="T3">第三个参数类型</typeparam>
		/// <typeparam name="T4">第四个参数类型</typeparam>
		/// <typeparam name="T5">第五个参数类型</typeparam>
		/// <typeparam name="T6">第六个参数类型</typeparam>
		/// <typeparam name="T7">第七个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <param name="value3">类型三对象</param>
		/// <param name="value4">类型四对象</param>
		/// <param name="value5">类型五对象</param>
		/// <param name="value6">类型六对象</param>
		/// <param name="value7">类型七对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000105 RID: 261 RVA: 0x0000584C File Offset: 0x00003A4C
		public static OperateResult<T1, T2, T3, T4, T5, T6, T7> CreateSuccessResult<T1, T2, T3, T4, T5, T6, T7>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6, T7>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2,
				Content3 = value3,
				Content4 = value4,
				Content5 = value5,
				Content6 = value6,
				Content7 = value7
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有八个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <typeparam name="T3">第三个参数类型</typeparam>
		/// <typeparam name="T4">第四个参数类型</typeparam>
		/// <typeparam name="T5">第五个参数类型</typeparam>
		/// <typeparam name="T6">第六个参数类型</typeparam>
		/// <typeparam name="T7">第七个参数类型</typeparam>
		/// <typeparam name="T8">第八个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <param name="value3">类型三对象</param>
		/// <param name="value4">类型四对象</param>
		/// <param name="value5">类型五对象</param>
		/// <param name="value6">类型六对象</param>
		/// <param name="value7">类型七对象</param>
		/// <param name="value8">类型八对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000106 RID: 262 RVA: 0x000058C0 File Offset: 0x00003AC0
		public static OperateResult<T1, T2, T3, T4, T5, T6, T7, T8> CreateSuccessResult<T1, T2, T3, T4, T5, T6, T7, T8>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6, T7, T8>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2,
				Content3 = value3,
				Content4 = value4,
				Content5 = value5,
				Content6 = value6,
				Content7 = value7,
				Content8 = value8
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有九个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <typeparam name="T3">第三个参数类型</typeparam>
		/// <typeparam name="T4">第四个参数类型</typeparam>
		/// <typeparam name="T5">第五个参数类型</typeparam>
		/// <typeparam name="T6">第六个参数类型</typeparam>
		/// <typeparam name="T7">第七个参数类型</typeparam>
		/// <typeparam name="T8">第八个参数类型</typeparam>
		/// <typeparam name="T9">第九个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <param name="value3">类型三对象</param>
		/// <param name="value4">类型四对象</param>
		/// <param name="value5">类型五对象</param>
		/// <param name="value6">类型六对象</param>
		/// <param name="value7">类型七对象</param>
		/// <param name="value8">类型八对象</param>
		/// <param name="value9">类型九对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000107 RID: 263 RVA: 0x0000593C File Offset: 0x00003B3C
		public static OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9> CreateSuccessResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2,
				Content3 = value3,
				Content4 = value4,
				Content5 = value5,
				Content6 = value6,
				Content7 = value7,
				Content8 = value8,
				Content9 = value9
			};
		}

		/// <summary>
		/// 创建并返回一个成功的结果对象，并带有十个参数对象
		/// </summary>
		/// <typeparam name="T1">第一个参数类型</typeparam>
		/// <typeparam name="T2">第二个参数类型</typeparam>
		/// <typeparam name="T3">第三个参数类型</typeparam>
		/// <typeparam name="T4">第四个参数类型</typeparam>
		/// <typeparam name="T5">第五个参数类型</typeparam>
		/// <typeparam name="T6">第六个参数类型</typeparam>
		/// <typeparam name="T7">第七个参数类型</typeparam>
		/// <typeparam name="T8">第八个参数类型</typeparam>
		/// <typeparam name="T9">第九个参数类型</typeparam>
		/// <typeparam name="T10">第十个参数类型</typeparam>
		/// <param name="value1">类型一对象</param>
		/// <param name="value2">类型二对象</param>
		/// <param name="value3">类型三对象</param>
		/// <param name="value4">类型四对象</param>
		/// <param name="value5">类型五对象</param>
		/// <param name="value6">类型六对象</param>
		/// <param name="value7">类型七对象</param>
		/// <param name="value8">类型八对象</param>
		/// <param name="value9">类型九对象</param>
		/// <param name="value10">类型十对象</param>
		/// <returns>成的结果对象</returns>
		// Token: 0x06000108 RID: 264 RVA: 0x000059C4 File Offset: 0x00003BC4
		public static OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> CreateSuccessResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10)
		{
			return new OperateResult<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
			{
				IsSuccess = true,
				ErrorCode = 0,
				Message = StringResources.Language.SuccessText,
				Content1 = value1,
				Content2 = value2,
				Content3 = value3,
				Content4 = value4,
				Content5 = value5,
				Content6 = value6,
				Content7 = value7,
				Content8 = value8,
				Content9 = value9,
				Content10 = value10
			};
		}
	}
}
